// The Dart Project Fuzz Tester (1.2).
// Program generated as:
//   dart dartfuzz.dart --seed 3608420507

bool var0 = false;
bool var1 = false;
int var2 = -49;
double var3 = double.maxFinite;
String var4 = '5Cw)';
List<int> var5 = [8589934591];
Map<int, String> var6 = {
  0: '\u2665',
  1: '7\u{1f600}\u{1f600}t\u2665s',
  2: '\u2665&)I',
  3: 'G\u2665\u{1f600}e',
};

List<int> foo0(List<int> par1, int par2, int par3) {
  var6 ??= var6;
  var4 ??= '';
  par1 = var5;
  return [-94];
}

int foo1(Map<int, String> par1, bool par2) {
  print(
    (-((((var4 == (var4).toLowerCase()) ? false : par2)
        ? (-(double.nan))
        : (var1
              ? (((false ? true : var1)
                        ? (par2
                              ? ((-((double.maxFinite + var3)))).roundToDouble()
                              : (-(var3)))
                        : var3))
                    .abs()
              : var3)))),
  );
  {
    List<int> loc0 = [95];
    return var2;
  }
}

String foo2() {
  var3 += (true
      ? ((var3).remainder(
              (var1 ? (-(0.20648281590433248)) : double.maxFinite),
            ) +
            double.maxFinite)
      : (var3 * var3));
  var2 %= (var2--);
  var6 = var6;
  return (var1
      ? (false
            ? (((!(true)) || false) ? var4 : ((var6).isEmpty ? var4 : 'I#'))
            : var4)
      : 'XLH+c\u2665\u2665');
}

class X0 {
  String fld0_0 = '\u2665';

  String foo0_0() {
    if (((({0: 'e\u{1f600}mw', 1: 'XZPq', 2: '2l', 3: 'EI'} ??
                {
                  0: '1fG',
                  1: 'LV\u2665s\u{1f600}s\u2665',
                  2: '\u{1f600}#',
                  3: 'V',
                }) ??
            {0: 'Z6'}))
        .isNotEmpty) {
      var4 ??= var4;
    } else {
      if ((var5 ==
          ((var1
                  ? ((!((false
                            ? var1
                            : (!((true &&
                                  (var0
                                      ? (false ? (false ? false : var1) : true)
                                      : var1)))))))
                        ? var0
                        : var1)
                  : false)
              ? ((([-9223372030412324863, 21, -97] + var5) ??
                        ([-9223372034707292160, -16, 6] + var5)) +
                    ([83, -52, 18]).sublist((++var2)))
              : ((var1 ? var5 : var5)).sublist(foo1(var6, true))))) {
        {
          int loc0 = (var2--);
          if (false) {
            fld0_0 ??= '\u26655JnN';
            {
              Map<int, String> loc1 = var6;
              return var4;
            }
          }
        }
      }
    }
    return '1f';
  }

  void run() {
    if ((foo0(
          [-23, -74, 8589934591],
          (true ? (-(-9223372030412324863)) : var2),
          (var0
              ? var2
              : foo1({
                  0: 'kU0',
                  1: '\u{1f600}',
                  2: '\u2665M',
                }, (var1 && (var2).isEven))),
        ) ==
        [81, -9223372030412324865, 56, 62])) {
      var6 ??= {0: '\u{1f600}\u{1f600}D\u26652', 1: 'yJb\u26657+'};
      return;
    } else {
      return;
    }
  }
}

class X1 extends X0 {
  double fld1_0 = 0.6358731486904787;

  bool foo1_0() {
    {
      List<int> loc0 =
          (foo0(
            var5,
            (var1 ? foo1({0: '\u26657@MJF', 1: 'J'}, true) : (~((--var2)))),
            ([6442450945]).removeLast(),
          ) +
          foo0([58], (-(var2)), (var2++)));
      print(foo0([69], 97, 63));
      var5 = (((var5).sublist(
        var2,
      )).sublist(var2)).sublist(((-(var3))).toInt());
    }
    var1 = (!(var0));
    print((!(((-(double.infinity)) != double.minPositive))));
    return var0;
  }

  List<int> foo1_1(bool par1, double par2, int par3) {
    print(foo2());
    fld1_0 = (-(double.infinity));
    var0 =
        (([
          -9223372036854775808,
          -19,
        ]).remove(foo1(var6, ((-((par3++))) < var2)))
        ? (var4 == 'Z72')
        : var1);
    return foo0(
      foo0(
        (foo0(
              ([14, -79] ?? var5),
              (-(par3)),
              ((true ? true : (!(var1))) ? (var0 ? (-73 * par3) : 53) : 66),
            ) +
            (var1 ? var5 : [17])),
        ((true ? var1 : (par1 ? (!(false)) : par1)) ? par3 : var2),
        foo1(var6, true),
      ),
      foo1({0: '1okmvo', 1: 'Cyn', 2: 'Iq\u{1f600}'}, (!((!(foo1_0()))))),
      (par1 ? (~((foo1_0() ? (--var2) : -1))) : (par1 ? var2 : 74)),
    );
  }

  void run() {
    super.run();
    if ((false
        ? var0
        : ({0: 'SVw', 1: '\u266576Q', 2: '\u2665b&E'}).containsValue(var4))) {
      return;
    }
  }
}

class X2 extends X1 {
  String fld2_0 = '';
  Map<int, String> fld2_1 = {
    0: '\u{1f600}\u2665F8',
    1: '\u{1f600}Kd',
    2: 'CW6e@d',
  };
  Map<int, String> fld2_2 = {
    0: 'MM3Ogd\u{1f600}',
    1: 'D',
    2: 'I\u{1f600}2kH4\u{1f600}',
  };

  List<int>? foo2_0(String par1, double par2, int par3) {
    var6 ??=
        ({0: 'hVMi', 1: '', 2: 'S'} ??
        {
          0: '9c\u{1f600}\u{1f600}\u{1f600}dW',
          1: 'g(Fu\u{1f600}bX',
          2: 'Pi2Z\u{1f600}',
          3: 'O\u2665',
        });
    for (int loc0 = 0; loc0 < 84; loc0++) {
      return (((!((!(var1)))) ? false : false)
          ? var5
          : (false ? var5 : [-9223372030412324864]));
    }
  }

  bool foo2_1(int par1, String par2) {
    {
      double loc0 = var3;
      fld2_2 = {0: 'mWycw'};
      var0 = true;
    }
    return (var1 ? ((par1++) != foo1(fld2_1, (!(false)))) : true);
  }

  Map<int, String> foo2_2() {
    {
      String loc0 = 'Am 3x';
      return fld2_1;
    }
  }

  double? foo2_3(List<int> par1) {
    var6 = foo2_2();
    if (var1) {
      print({0: 'K\u{1f600}\u{1f600}\u2665\u{1f600}', 1: 'lh34LP'});
      print('im\u2665');
      {
        String loc0 = (var1
            ? ('y\u2665E4UQQ' + ('Q0J2  y').substring(-78))
            : foo2());
        {
          bool loc1 = (((-(-92))).isOdd && (!((!(false)))));
          print(var3);
          if ((var2).isEven) {
            var3 /= 0.536905815119827;
            var2 |= (++var2);
            {
              double loc2 = var3;
              {
                int loc3 = foo1({
                  0: 'G(',
                  1: '\u{1f600}&a9t',
                  2: '\u{1f600}TF',
                  3: '\u2665m-',
                }, true);
                var4 ??= (loc0).substring(
                  ((((par1 ?? [-9223372034707292159, 44, -1, 2147483648]))
                              .remove(
                                (false
                                    ? -9223372032559808511
                                    : (((++loc3) ~/ (2147483649 | 54))).ceil()),
                              ) ||
                          false)
                      ? (~((loc3++)))
                      : (foo1(fld2_1, (var6 == {0: '', 1: 'KP8'})) >> 50)),
                );
                if ((true !=
                    ((!(loc1))
                        ? ((-(40)) >= -32)
                        : foo2_1(
                            9223372034707292159,
                            (foo2_2()).remove(
                              (((-((loc3).abs())) ~/ 42)).toSigned(-27),
                            )!,
                          )))) {
                  if (loc1) {
                    return loc2;
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  void run() {
    super.run();
    fld2_2 ??= (var1 ? fld2_2 : {0: 'M ', 1: 'zG', 2: 'c'});
    if (((foo2_1(var2, var4)
            ? ((false
                      ? ((var1 || (true && foo2_1(9223372032559808512, var4)))
                            ? var5
                            : var5)
                      : ([-52]).sublist((true ? 24 : var2))))
                  .remove(9223372036854775807)
            : false) &&
        var0)) {
      for (int loc0 = 0; loc0 < 57; loc0++) {
        var5 ??= (([26, 82, -9223372032559808512]).sublist((-22 >> 27)) + var5);
        var6 ??= fld2_2;
        fld2_0 ??= foo2();
        for (int loc1 = 0; loc1 < 67; loc1++) {
          for (int loc2 = 0; loc2 < 31; loc2++) {
            var4 = foo2();
            {
              bool loc3 = foo2_1(
                (-(((!(var0))
                    ? foo1(fld2_2, true)
                    : foo1(
                        (foo2_1(
                              (false
                                  ? ([-74, -49, -79, 2]).length
                                  : 9223372034707292161),
                              'y',
                            )
                            ? ({0: '\u{1f600}Jf', 1: 'NF'} ??
                                  {0: '1 y\u{1f600}\u26659'})
                            : {
                                0: '6MO\u2665A\u{1f600})',
                                1: 'p\u{1f600}\u{1f600}6J',
                                2: 'sg)',
                              }),
                        var0,
                      )))),
                fld2_0,
              );
              var5 ??= var5;
              for (int loc4 = 0; loc4 < 78; loc4++) {
                return;
              }
            }
          }
        }
      }
    }
  }
}

class X3 extends X2 {
  List<int> fld3_0 = [-4, -4, -79, 34];

  bool foo3_0(int par1, List<int> par2) {
    return (((var1 ? 60 : var2)).isOdd
        ? ((var1 ? fld3_0 : par2)).remove(foo1(var6, (var1 != var0)))
        : (false
              ? false
              : (('GB').substring(
                  (++var2),
                )).endsWith(('p\u{1f600}f1u\u2665' ?? 'L\u2665OY!ui'))));
  }

  int foo3_1(List<int> par1, int par2, bool par3) {
    if (true) {
      return par2;
    }
  }

  List<int>? foo3_2(List<int> par1, List<int> par2) {
    for (int loc0 = 0; loc0 < 68; loc0++) {
      {
        String loc1 = foo2();
        var2 -= (~((false
            ? (~((false ? loc0 : -9223372034707292161)))
            : (var2--))));
        for (int loc2 = 0; loc2 < 95; loc2++) {
          var3 ??=
              ((false ? var3 : (-(var3))) *
              (var3 ??
                  ((-(double.negativeInfinity))).remainder(
                    (var3 * double.nan),
                  )));
          if ((loc1).endsWith('')) {
            print(
              (((!(foo3_0(-47, par2)))
                      ? par1
                      : ([2, -52, -9223372032559808512, 2147483649] + par2)))
                  .removeLast(),
            );
            var2 -= foo3_1(
              (foo0(
                (foo0(
                      ((var0 ? [-4294967295, -95, -22, 27] : [38]) +
                          [2147483647]),
                      (var3).truncate(),
                      var2,
                    ) ??
                    par1),
                (~(loc0)),
                53,
              )).sublist((--loc0)),
              ((loc2++) ??
                  ((!((false || var0)))
                      ? (69 +
                            (47 &
                                (foo0(
                                  [24, -98, 2147483647, -48],
                                  loc0,
                                  47,
                                )).indexOf(37)))
                      : (var4).compareTo((var1 ? loc1 : loc1)))),
              (foo3_0(
                    (var2 + (~(loc2))),
                    foo0(([20, 13] + par2), loc0, var2),
                  ) &&
                  (loc1).isNotEmpty),
            );
            for (int loc3 = 0; loc3 < 62; loc3++) {
              for (int loc4 = 0; loc4 < 61; loc4++) {
                return fld3_0;
              }
            }
          }
        }
      }
    }
  }

  bool? foo3_3(List<int> par1, Map<int, String> par2, Map<int, String> par3) {
    for (int loc0 = 0; loc0 < 16; loc0++) {
      if (foo3_0(
        (-((var0 ? 8589934591 : 65))),
        foo3_2(
          fld3_0,
          (fld3_0).sublist((true ? (0.23821360229648214).toInt() : var2)),
        )!,
      )) {
        par1 ??= (((var4 == '&Tze') ? ([-27, 23, -40] != par1) : true)
            ? [23, 21, 4294967295]
            : fld3_0);
        print(
          (par2 ?? {0: '\u{1f600}\u2665\u{1f600}Jpj&', 1: '', 2: '', 3: ''}),
        );
        var4 = var4;
        var1 = (((~(((++loc0) ?? loc0)))).isEven == false);
      }
      for (int loc1 = 0; loc1 < 93; loc1++) {
        var4 = 'gngT';
        return (foo3_0(
              ((((var3 * (loc1).ceilToDouble()) -
                          ((0.6230577340230226 > var3)
                              ? (var3 - var3)
                              : double.maxFinite)) -
                      double.nan))
                  .ceil(),
              [0],
            )
            ? ((!(var0)) && foo3_0((-(-59)), [8, 1, 12, -9223372030412324863]))
            : foo3_0(
                foo3_1(foo3_2([2, -33, -72], [30, 58, 0])!, loc1, (!(var1))),
                var5,
              ));
      }
    }
  }

  void run() {
    super.run();
    var1 = (var6).containsKey((var0 ? (30).floor() : (~((++var2)))));
  }
}

main() {
  try {
    new X3().run();
  } catch (e) {
    print('throws');
  } finally {
    print('$var0\n$var1\n$var2\n$var3\n$var4\n$var5\n$var6\n');
  }
}
